home *** CD-ROM | disk | FTP | other *** search
/ Network CD 2 / Network CD - Volume 2.iso / programs / internet / tcp / mail / sabot18.lha / Sabot / Source / mm.c next >
Encoding:
C/C++ Source or Header  |  1994-04-04  |  13.1 KB  |  762 lines
  1. /* Sabot */
  2.  
  3. #include <exec/types.h>
  4. #include <exec/libraries.h>
  5. #include <exec/memory.h>
  6. #include <dos/dos.h>
  7. #include <dos/notify.h>
  8. #include <dos/dostags.h>
  9. #include <libraries/dos.h>
  10. #include <workbench/workbench.h>
  11. #include <workbench/startup.h>
  12.  
  13. #include <proto/icon.h>
  14. #include <proto/exec.h>
  15. #include <proto/wb.h>
  16. #include <proto/dos.h>
  17. #ifdef TIMER
  18. #include <proto/timer.h>
  19. #include <time.h>
  20. #endif
  21.  
  22. #include <strings.h>
  23. #include <stdlib.h>
  24. #include <stdio.h>
  25. #include <wb2cli.h>
  26.  
  27. #define BIGSTRING 255
  28. #define SMALLSTRING 128
  29.  
  30. enum args
  31.     {
  32.     MAIL,
  33.     NOMAIL,
  34.     OLDMAIL,
  35.     MAILBOX,
  36.     ICONNAME,
  37.     XPOS,
  38.     YPOS,
  39.     CLICKCOMMAND,
  40.     CLICKSTACK,
  41.     MAILCOMMAND,
  42.     MAILSTACK,
  43.     DROPCOMMAND,
  44.     DROPSTACK,
  45.     BEEPLOTS,
  46.     COUNTDELETE,
  47. #ifdef TIMER
  48.     TIME,
  49. #endif
  50.     MAILRDY
  51.     };
  52.  
  53.  
  54.  
  55. void __regargs __chkabort(void) {}
  56. int __oslibversion=37;
  57. long __stack = 20000;
  58. #ifndef TIMER
  59. static const char VersionID[]="\0$VER:Sabot 1.8 "__AMIGADATE__;
  60. #endif
  61. #ifdef TIMER
  62. static const char VersionID[]="\0$VER:Sabot-Timer 1.8 "__AMIGADATE__;
  63. #endif
  64.  
  65. extern struct DosLibrary *DOSBase;
  66. extern struct WBStartup *_WBenchMsg;
  67. struct Library *IconBase;
  68. struct Library *WorkbenchBase;
  69.  
  70. char *havemail;
  71. char *nomail;
  72. char *oldmail;
  73. char *watch;
  74. char *iconname;
  75. char *clickcomname;
  76. char *mailcomname;
  77. char *dropcomname;
  78. char *dropname;
  79. char *droptemp;
  80.  
  81. BOOL mailrdy=FALSE;
  82. ULONG xpos;
  83. ULONG ypos;
  84.  
  85. BOOL beeplots=FALSE;
  86. ULONG clickcomstack=20000;
  87. ULONG mailcomstack=20000;
  88. ULONG dropcomstack=20000;
  89.  
  90. LONG mbsize=0;
  91. LONG prevsize=0;
  92.  
  93. struct AppIcon *appicon=NULL;
  94. struct DiskObject *image=NULL;
  95. struct MsgPort *myport=NULL;
  96.  
  97. struct RDArgs   *RDA;
  98.  
  99. enum active_args
  100.     {
  101.     NONE,
  102.     OLD,
  103.     NEW
  104.     };
  105.  
  106. USHORT active=NONE;
  107. BOOL beeped=FALSE;
  108. BOOL countdelete=FALSE;
  109.  
  110. #ifdef TIMER
  111. int setuptime( void );
  112. int closetime(void );
  113. void timereq( void );
  114. struct MsgPort *timer_mp;
  115. struct timerequest *timerio;
  116. extern struct Library *TimerBase;
  117. int timecheck=5;
  118. #endif
  119.  
  120. BOOL addicon(struct MsgPort *, struct DiskObject *);
  121. void killicon( void );
  122. BOOL getimage( char * );
  123. void killimage( void );
  124. void changeicon( void );
  125. void doinfo( void );
  126. void compare( void );
  127. BOOL parse( int );
  128. void FreeParameters( LONG * );
  129. void docommand(char *, int);
  130. BOOL makevars( void );
  131. void freevars( void );
  132.  
  133. int main (int argc, char **argv)
  134. {
  135.     struct AppMessage *appmsg;
  136.  
  137. #ifndef TIMER
  138.     struct NotifyRequest *note;
  139. #endif
  140.  
  141.     struct MsgPort *mailport=NULL;
  142.     ULONG mailportsig=NULL;
  143.  
  144.     BOOL going=TRUE;
  145.     ULONG mysig;
  146.     LONG signum;
  147.     LONG count;
  148.     ULONG myportsig;
  149.  
  150.     if ( !makevars() )
  151.     {
  152.         freevars();
  153.         return(20);
  154.     }
  155.  
  156.     WB2CLI( _WBenchMsg , __stack , DOSBase); /* Creates Path for System()'ed commands */
  157.  
  158.     if ( !parse(argc) )
  159.     {
  160.         freevars();
  161.         return(5);
  162.     }
  163.  
  164.     if (mailrdy)
  165.     {
  166.         if ( mailport=CreatePort("T:MailRdy",0) )
  167.         {
  168.             mailportsig = 1L << mailport->mp_SigBit;
  169.         }
  170.     }
  171.  
  172.     if ( (IconBase=OpenLibrary("icon.library",37)) && (WorkbenchBase=OpenLibrary("workbench.library",37)) )
  173.     {
  174.         if ( getimage(nomail) )
  175.         {
  176.             if ( myport=CreatePort(NULL,0) )
  177.             {
  178.                 myportsig = 1L << myport->mp_SigBit;
  179.  
  180.                 if ( addicon(myport,image) )
  181.                 {
  182. #ifndef TIMER
  183.                     if ( note=AllocVec(sizeof(struct NotifyRequest),MEMF_CLEAR) )
  184.                     {
  185.                         if ( (signum=AllocSignal(-1L)) != -1)
  186.                         {
  187.                             note->nr_Name=watch;
  188.                             note->nr_Flags=NRF_SEND_SIGNAL;
  189.                             note->nr_stuff.nr_Signal.nr_Task= (struct Task *)FindTask(NULL);
  190.                             note->nr_stuff.nr_Signal.nr_SignalNum=signum;
  191.  
  192.                             if ( (StartNotify(note))==DOSTRUE )
  193.                             {
  194.                                 doinfo();
  195.                                 if ( mbsize )        /* Show appropriate icon on startup */
  196.                                 {
  197.                                     active=OLD;
  198.                                     changeicon();
  199.                                 }
  200. #endif
  201. #ifdef TIMER
  202.                 if ( setuptime() )
  203.                 {
  204.                     signum = timer_mp->mp_SigBit;
  205.                     timereq();
  206.                     doinfo();
  207.                     prevsize=mbsize;
  208.                     compare();
  209. #endif
  210.  
  211.                                 while ( going )
  212.                                 {
  213.                                     mysig = Wait( myportsig | SIGBREAKF_CTRL_C | (1L << signum) | mailportsig );
  214.  
  215.                                     if ( mysig & SIGBREAKF_CTRL_C )
  216.                                     {
  217.                                         going=FALSE;
  218.                                     }
  219.  
  220.                                     if (mysig & mailportsig)
  221.                                     {
  222.                                         active=OLD;
  223.                                         changeicon();
  224.                                     }
  225.  
  226.                                     if (mysig & (1L << signum))
  227.                                     {
  228.                                         doinfo();
  229.                                         compare();
  230. #ifdef TIMER
  231.                                         timereq();
  232. #endif
  233.                                     }
  234.  
  235.                                     if ( mysig & myportsig)
  236.                                     {
  237. #ifdef TIMER
  238.                                         prevsize=mbsize;
  239. #endif
  240.                                         if ( mailrdy && (active!=NONE) )
  241.                                         {
  242.                                             active=NONE;
  243.                                             changeicon();
  244.                                         }
  245.  
  246.                                         while( appmsg=(struct AppMessage *)GetMsg(myport) )
  247.                                         {
  248.                                             if ( appmsg->am_NumArgs==0L )
  249.                                             {
  250.                                                 if ( clickcomname )
  251.                                                 {
  252.                                                     docommand(clickcomname,clickcomstack);
  253.                                                 }
  254.                                                 prevsize=mbsize;
  255.                                             }
  256.                                             else if ( appmsg->am_NumArgs > 0L )
  257.                                             {
  258.                                                 if ( dropcomname )
  259.                                                 {
  260.                                                     count = appmsg->am_NumArgs;
  261.  
  262.                                                     while ( count )
  263.                                                     {
  264.                                                         --count;
  265.  
  266.                                                         if (NameFromLock(appmsg->am_ArgList[count].wa_Lock,dropname,BIGSTRING))
  267.                                                         {
  268.                                                             if(AddPart(dropname,appmsg->am_ArgList[count].wa_Name,BIGSTRING))
  269.                                                             {
  270.                                                                 sprintf(droptemp,"%s \"%s\"",dropcomname,dropname);
  271.                                                                 docommand(droptemp,dropcomstack);
  272.                                                             }
  273.                                                         }
  274.  
  275.                                                         strcpy(droptemp,"");
  276.                                                         strcpy(dropname,"");
  277.                                                     }
  278.                                                 }
  279.                                             }
  280.                                             ReplyMsg( (struct Message *)appmsg );
  281.                                         }
  282.                                     }
  283. #ifdef TIMER
  284.                 }
  285.             closetime();
  286. #endif
  287. #ifndef TIMER
  288.                                 }
  289.                             }
  290.                             FreeSignal(signum);
  291.                         }
  292.                         EndNotify(note);
  293.                         FreeVec(note);
  294. #endif
  295.                     }
  296.                 }
  297.                 killicon();
  298.             }
  299.  
  300.             while(appmsg=(struct AppMessage *)GetMsg(myport))
  301.             {
  302.                 ReplyMsg((struct Message *)appmsg);
  303.             }
  304.  
  305.             DeletePort(myport);
  306.         }
  307.         killimage();
  308.     }
  309.  
  310.     if (mailport)
  311.     {
  312.         DeletePort(mailport);
  313.     }
  314.  
  315.     CloseLibrary(WorkbenchBase);
  316.     CloseLibrary(IconBase);
  317.  
  318.     freevars();
  319.  
  320.     return(0);
  321. }
  322.  
  323. BOOL addicon(struct MsgPort *port, struct DiskObject *image)
  324. {
  325.     if ( appicon=AddAppIconA(0L,0L,iconname,port,NULL,image,NULL) )
  326.     {
  327.         return(TRUE);
  328.     }
  329.  
  330.     return(FALSE);
  331. }
  332.  
  333. void killicon( void )
  334. {
  335.     RemoveAppIcon(appicon);
  336. }
  337.  
  338. BOOL getimage( char *name )
  339. {
  340.     if ( image=GetDiskObject(name) )
  341.     {
  342.         image->do_Type=NULL;
  343.         image->do_CurrentX=xpos;
  344.         image->do_CurrentY=ypos;
  345.         return(TRUE);
  346.     }
  347.  
  348.     return(FALSE);
  349. }
  350.  
  351. void killimage( void )
  352. {
  353.     if (image)
  354.     {
  355.         FreeDiskObject(image);
  356.     }
  357. }
  358.  
  359. void changeicon( void )
  360. {
  361.     killicon();
  362.     killimage();
  363.  
  364.     switch (active)
  365.     {
  366.         case OLD:
  367.             getimage(oldmail);
  368.             break;
  369.  
  370.         case NEW:
  371.             getimage(havemail);
  372.             break;
  373.  
  374.         case NONE:
  375.             getimage(nomail);
  376.             break;
  377.     }
  378.  
  379.     addicon(myport,image);
  380. }
  381.  
  382. void doinfo( void )
  383. {
  384.     BPTR lock;
  385.     struct FileInfoBlock *fib;
  386.  
  387.     if ( lock=Lock(watch,ACCESS_READ) )
  388.     {
  389.         if ( fib=(struct FileInfoBlock *)AllocDosObject(DOS_FIB,TAG_END) )
  390.         {
  391.             Examine(lock,fib);
  392.  
  393.             mbsize=fib->fib_Size;
  394.  
  395.             FreeDosObject(DOS_FIB,fib);
  396.         }
  397.     }
  398.     else
  399.     {
  400.         if ( countdelete ) mbsize=0;
  401.     }
  402.  
  403.     UnLock(lock);
  404. }
  405.  
  406. void compare( void )
  407. {
  408.     if (mbsize)
  409.     {
  410.         if ( mbsize > (prevsize+130) ) /* Allow 130 bytes of breathing room */
  411.         {
  412.             if (active!=NEW)
  413.             {
  414.                 active=NEW;
  415.                 changeicon();
  416.             }
  417.  
  418.             if ( mailcomname && ( !beeped || beeplots) )
  419.             {
  420.                 docommand(mailcomname,mailcomstack);
  421.                 beeped=TRUE;
  422.             }
  423.         }
  424.         else
  425.         {
  426. #ifdef TIMER
  427.             if ( active != OLD )
  428.             {
  429. #endif
  430.             active=OLD;
  431.             changeicon();
  432.             beeped=FALSE;
  433. #ifdef TIMER
  434.             }
  435. #endif
  436.         }
  437.     }
  438.     else
  439.     {
  440. #ifdef TIMER
  441.         if ( active != NONE )
  442.         {
  443. #endif
  444.         active=NONE;
  445.         changeicon();
  446.         beeped=FALSE;
  447. #ifdef TIMER
  448.         }
  449. #endif
  450.     }
  451.  
  452. #ifndef TIMER
  453.     prevsize=mbsize;
  454. #endif
  455.  
  456. }
  457.  
  458. BOOL parse(int argc)
  459. {
  460.     char    *OriginalTemplate = "Mail/A,NoMail/A,OldMail/A,"
  461.                                 "MB=MailBox/A,IN=IconName/K,"
  462.                                 "XPos/K/N,YPos/K/N,CC=ClickCommand/K,"
  463.                                 "CS=ClickStack/K/N,MC=MailCommand/K,"
  464.                                 "MS=MailStack/K/N,DC=DropCommand/K,"
  465.                                 "DS=DropStack/K/N,BeepLots/S,CountDelete/S,"
  466. #ifdef TIMER
  467.                                 "Time/K/N,"
  468. #endif
  469.                                 "MailRdy/S";
  470.  
  471.  
  472.     LONG    *ArgumentArray;        /* array for storing arguments retrieved by */
  473.  
  474.     char    **ToolArrayIndex,    /* workbench tooltypes array */
  475.             *ToolStringIndex,    /* index into string of concatenated workbench tooltypes */
  476.             *Template;            /* readargs template - varies slightly for WB or CLI */
  477.  
  478.     struct DiskObject    *DiskObject;    /* pointer to diskobject associated with program icon */
  479.     WORD    ArgCount = 1;        /* number of arguments in template */
  480.  
  481.  
  482.     RDA = AllocDosObjectTags(DOS_RDARGS, TAG_DONE);
  483.     RDA->RDA_ExtHelp = NULL;
  484.  
  485.     Template = AllocVec(strlen(OriginalTemplate)+16,MEMF_CLEAR);
  486.  
  487.     for (    ToolStringIndex = OriginalTemplate;
  488.             ToolStringIndex = strchr(ToolStringIndex,',');
  489.             ToolStringIndex++, ArgCount++);
  490.  
  491.     ArgumentArray = AllocVec((ArgCount+1)*4,MEMF_CLEAR);
  492.  
  493.     if (argc==0)
  494.     {
  495.         if (IconBase = OpenLibrary("icon.library", 36L ) )
  496.         {
  497.  
  498.             CurrentDir(_WBenchMsg->sm_ArgList->wa_Lock);
  499.  
  500.             if (DiskObject = GetDiskObject(_WBenchMsg->sm_ArgList->wa_Name))
  501.             {
  502.                 for (    ToolArrayIndex = DiskObject->do_ToolTypes;
  503.                         *ToolArrayIndex;
  504.                         ToolArrayIndex++)
  505.                 {
  506.                     RDA->RDA_Source.CS_Length += (strlen(*ToolArrayIndex)+1);
  507.                 }
  508.  
  509.                 if (RDA->RDA_Source.CS_Length)
  510.                 {
  511.                     RDA->RDA_Source.CS_Buffer = AllocVec(RDA->RDA_Source.CS_Length+1,MEMF_CLEAR);
  512.                     ToolStringIndex = RDA->RDA_Source.CS_Buffer;
  513.  
  514.                     for (    ToolArrayIndex = DiskObject->do_ToolTypes;
  515.                             *ToolArrayIndex;
  516.                             ToolArrayIndex++)
  517.                     {
  518.                         ToolStringIndex = stpcpy(stpcpy(ToolStringIndex,*ToolArrayIndex)," ");
  519.                     }
  520.  
  521.                     *(ToolStringIndex-1) = '\n';
  522.                     FreeDiskObject(DiskObject);
  523.                 }
  524.             }
  525.  
  526.             stpcpy(stpcpy(Template,OriginalTemplate),",ThrowAway/M");
  527.  
  528.             CloseLibrary(IconBase);
  529.         }
  530.     }
  531.     else
  532.     {
  533.         strcpy(Template,OriginalTemplate);
  534.     }
  535.  
  536.     RDA = ReadArgs(Template,ArgumentArray,RDA);
  537.  
  538.     FreeVec(Template);
  539.  
  540.     if (RDA)
  541.     {
  542.         strcpy(havemail,(char *)ArgumentArray[MAIL]);
  543.         strcpy(nomail,(char *)ArgumentArray[NOMAIL]);
  544.         strcpy(oldmail,(char *)ArgumentArray[OLDMAIL]);
  545.         strcpy(watch,(char *)ArgumentArray[MAILBOX]);
  546.  
  547.         if ( ArgumentArray[ICONNAME] )
  548.         {
  549.             strcpy(iconname,(char *)ArgumentArray[ICONNAME]);
  550.         }
  551.         else
  552.         {
  553.             strcpy(iconname,"MailBox");
  554.         }
  555.  
  556.         if ( ArgumentArray[XPOS] )
  557.         {
  558.             xpos=*(int *)ArgumentArray[XPOS];
  559.         }
  560.         else
  561.         {
  562.             xpos=NO_ICON_POSITION;
  563.         }
  564.  
  565.         if ( ArgumentArray[YPOS] )
  566.         {
  567.             ypos=*(int *)ArgumentArray[YPOS];
  568.         }
  569.         else
  570.         {
  571.             ypos=NO_ICON_POSITION;
  572.         }
  573.  
  574.         if ( ArgumentArray[CLICKCOMMAND] )
  575.         {
  576.             strcpy(clickcomname,(char *)ArgumentArray[CLICKCOMMAND]);
  577.         }
  578.  
  579.         if ( ArgumentArray[CLICKSTACK] )
  580.         {
  581.             clickcomstack=*(int *)ArgumentArray[CLICKSTACK];
  582.         }
  583.  
  584.         if ( ArgumentArray[MAILCOMMAND] )
  585.         {
  586.             strcpy(mailcomname,(char *)ArgumentArray[MAILCOMMAND]);
  587.         }
  588.  
  589.         if ( ArgumentArray[MAILSTACK] )
  590.         {
  591.             mailcomstack=*(int *)ArgumentArray[MAILSTACK];
  592.         }
  593.  
  594.         if ( ArgumentArray[DROPCOMMAND] )
  595.         {
  596.             strcpy(dropcomname,(char *)ArgumentArray[DROPCOMMAND]);
  597.         }
  598.  
  599.         if ( ArgumentArray[DROPSTACK] )
  600.         {
  601.             dropcomstack=*(int *)ArgumentArray[DROPSTACK];
  602.         }
  603.  
  604.         if ( ArgumentArray[BEEPLOTS] )
  605.         {
  606.             beeplots=TRUE;
  607.         }
  608.  
  609.         if ( ArgumentArray[COUNTDELETE] )
  610.         {
  611.             countdelete=TRUE;
  612.         }
  613.  
  614. #ifdef TIMER
  615.         if ( ArgumentArray[TIME] )
  616.         {
  617.             timecheck=*(int *)ArgumentArray[TIME];
  618.         }
  619. #endif
  620.  
  621.         if ( ArgumentArray[MAILRDY] )
  622.         {
  623.             mailrdy=TRUE;
  624.         }
  625.  
  626.         FreeParameters(ArgumentArray);
  627.  
  628.         return(TRUE);
  629.     }
  630.     else
  631.     {
  632.         FreeParameters(ArgumentArray);
  633.  
  634.         return(FALSE);
  635.     }
  636. }
  637.  
  638. void FreeParameters(LONG *ArgumentArray)
  639. {
  640.     if (RDA)
  641.     {
  642.         if ((RDA->RDA_Source.CS_Length) && (RDA->RDA_Source.CS_Buffer))
  643.         {
  644.             FreeVec(RDA->RDA_Source.CS_Buffer);
  645.         }
  646.  
  647.         FreeArgs(RDA);
  648.         FreeDosObject(DOS_RDARGS,RDA);
  649.     }
  650.     else
  651.     {
  652.         PrintFault(IoErr(), NULL);
  653.     }
  654.  
  655.     if (ArgumentArray)
  656.     {
  657.         FreeVec(ArgumentArray);
  658.     }
  659. }
  660.  
  661. void docommand(char *command, int stack)
  662. {
  663.     BPTR ofh,ifh;
  664.  
  665.     if ( ofh=Open("NIL:",MODE_READWRITE) )
  666.     {
  667.         if ( ifh=Open("NIL:",MODE_READWRITE) )
  668.         {
  669.             if ( SystemTags(    command,
  670.                         SYS_Input, ifh,
  671.                         SYS_Output, ofh,
  672.                         SYS_UserShell, DOSTRUE,
  673.                         SYS_Asynch, DOSTRUE,
  674.                         NP_StackSize, stack,
  675.                         NP_CopyVars, DOSTRUE,
  676.                         NP_Cli, DOSTRUE,
  677.                         TAG_END) != -1 )
  678.             {
  679.                 return;
  680.             }
  681.  
  682.             Close(ifh);
  683.         }
  684.         Close(ofh);
  685.     }
  686. }
  687.  
  688. BOOL makevars(void)
  689. {
  690.     if ( havemail=AllocVec(11*BIGSTRING,MEMF_CLEAR) )
  691.     {
  692.         nomail=havemail+BIGSTRING;
  693.         oldmail=nomail+BIGSTRING;
  694.         watch=oldmail+BIGSTRING;
  695.         iconname=watch+BIGSTRING;
  696.         clickcomname=iconname+BIGSTRING;
  697.         mailcomname=clickcomname+BIGSTRING;
  698.         dropcomname=mailcomname+BIGSTRING;
  699.         dropname=dropcomname+BIGSTRING;
  700.         droptemp=dropname+(2*BIGSTRING);
  701.         return(TRUE);
  702.     }
  703.     return(FALSE);
  704. }
  705.  
  706. void freevars(void)
  707. {
  708.     if (havemail) FreeVec(havemail);
  709. }
  710.  
  711. #ifdef TIMER
  712.  
  713. int setuptime( void )
  714. {
  715.     timer_mp = CreateMsgPort();
  716.  
  717.     if (timer_mp == NULL )
  718.     {
  719.         return(0);
  720.     }
  721.  
  722.     timerio=(struct timerequest *)CreateExtIO(timer_mp,sizeof(struct timerequest));
  723.  
  724.     if ( OpenDevice(TIMERNAME,UNIT_VBLANK,(struct IORequest *)timerio,0) )
  725.     {
  726.         return(0);
  727.     }
  728.     return(1);
  729. }
  730.  
  731. int closetime( void )
  732. {
  733.     if (timer_mp)
  734.     {
  735.         if (timerio)
  736.         {
  737.             AbortIO( (struct IORequest *)timerio);
  738.             WaitIO( (struct IORequest *)timerio);
  739.             CloseDevice( (struct IORequest *)timerio );
  740.             DeleteExtIO( (struct IORequest *)timerio);
  741.         }
  742.  
  743.         DeleteMsgPort(timer_mp);
  744.     }
  745.  
  746.     timer_mp=NULL;
  747.     timerio=NULL;
  748.  
  749.     return(0);
  750. }
  751.  
  752. void timereq(void)
  753. {
  754.     timerio->tr_node.io_Command    = TR_ADDREQUEST;
  755.     timerio->tr_time.tv_secs    = (60*timecheck);
  756.     timerio->tr_time.tv_micro    = 0;
  757.     SendIO( (struct IORequest *)timerio );
  758. }
  759.  
  760. #endif
  761.  
  762.